/**
 * 日期处理工具类
 */
export default {
  /**
   * 格式化日期时间
   * @param {Date|string} date - 日期对象或日期字符串
   * @param {string} format - 格式模式，默认为'YYYY-MM-DD HH:mm:ss'
   * @returns {string} 格式化后的日期字符串
   */
  formatDateTime(date, format = 'YYYY-MM-DD HH:mm:ss') {
    if (!date) return ''
    
    // 转换为Date对象
    const d = typeof date === 'string' ? new Date(date) : date
    
    // 检查是否为有效日期
    if (isNaN(d.getTime())) return ''
    
    const year = d.getFullYear()
    const month = String(d.getMonth() + 1).padStart(2, '0')
    const day = String(d.getDate()).padStart(2, '0')
    const hours = String(d.getHours()).padStart(2, '0')
    const minutes = String(d.getMinutes()).padStart(2, '0')
    const seconds = String(d.getSeconds()).padStart(2, '0')
    
    return format
      .replace('YYYY', year)
      .replace('MM', month)
      .replace('DD', day)
      .replace('HH', hours)
      .replace('mm', minutes)
      .replace('ss', seconds)
  },

  /**
   * 格式化日期（仅日期，不含时间）
   * @param {Date|string} date - 日期对象或日期字符串
   * @returns {string} 格式化后的日期字符串，格式为'YYYY-MM-DD'
   */
  formatDate(date) {
    return this.formatDateTime(date, 'YYYY-MM-DD')
  },

  /**
   * 格式化时间（仅时间，不含日期）
   * @param {Date|string} date - 日期对象或日期字符串
   * @returns {string} 格式化后的时间字符串，格式为'HH:mm:ss'
   */
  formatTime(date) {
    return this.formatDateTime(date, 'HH:mm:ss')
  },

  /**
   * 获取当前日期时间
   * @returns {Date} 当前日期时间对象
   */
  getCurrentDateTime() {
    return new Date()
  },

  /**
   * 获取当前日期
   * @returns {Date} 当前日期对象（时间部分为00:00:00）
   */
  getCurrentDate() {
    const now = new Date()
    return new Date(now.getFullYear(), now.getMonth(), now.getDate())
  },

  /**
   * 获取指定天数之前/之后的日期
   * @param {number} days - 天数，正数表示之后，负数表示之前
   * @param {Date} [date=new Date()] - 基准日期，默认为当前日期
   * @returns {Date} 计算后的日期对象
   */
  getRelativeDate(days, date = new Date()) {
    const result = new Date(date)
    result.setDate(result.getDate() + days)
    return result
  },

  /**
   * 判断是否为今天
   * @param {Date|string} date - 要判断的日期
   * @returns {boolean} 是否为今天
   */
  isToday(date) {
    const d = typeof date === 'string' ? new Date(date) : date
    const today = new Date()
    return d.getDate() === today.getDate() &&
           d.getMonth() === today.getMonth() &&
           d.getFullYear() === today.getFullYear()
  },

  /**
   * 判断是否为有效日期
   * @param {*} date - 要检查的值
   * @returns {boolean} 是否为有效日期
   */
  isValidDate(date) {
    return date instanceof Date && !isNaN(date.getTime())
  }
}

/**
 * 数字处理工具
 */
export const numberUtils = {
  /**
   * 格式化金额，保留两位小数
   * @param {number} amount - 金额
   * @returns {string} 格式化后的金额字符串
   */
  formatAmount(amount) {
    if (amount === null || amount === undefined || isNaN(amount)) return '0.00'
    return Number(amount).toFixed(2)
  },

  /**
   * 千分位格式化
   * @param {number} num - 要格式化的数字
   * @returns {string} 千分位格式化后的字符串
   */
  formatThousands(num) {
    if (num === null || num === undefined || isNaN(num)) return '0'
    return Number(num).toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',')
  }
}

/**
 * 字符串处理工具
 */
export const stringUtils = {
  /**
   * 截断字符串，超出部分用省略号表示
   * @param {string} str - 原始字符串
   * @param {number} maxLength - 最大长度
   * @returns {string} 截断后的字符串
   */
  truncate(str, maxLength) {
    if (!str || str.length <= maxLength) return str
    return str.substring(0, maxLength) + '...'
  },

  /**
   * 去除字符串两端的空白字符
   * @param {string} str - 原始字符串
   * @returns {string} 处理后的字符串
   */
  trim(str) {
    return str ? str.trim() : ''
  }
}